home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / karnov.c < prev    next >
C/C++ Source or Header  |  2000-04-04  |  8KB  |  313 lines
  1. /*******************************************************************************
  2.  
  3.     Karnov - Bryan McPhail, mish@tendril.co.uk
  4.  
  5. *******************************************************************************/
  6.  
  7. #include "driver.h"
  8. #include "vidhrdw/generic.h"
  9.  
  10. static unsigned char *karnov_foreground,*dirty_f;
  11. static struct osd_bitmap *bitmap_f;
  12. int karnov_scroll[4];
  13.  
  14. /***************************************************************************
  15.  
  16.   Convert the color PROMs into a more useable format.
  17.  
  18.   Karnov has two 1024x8 palette PROM.
  19.   I don't know the exact values of the resistors between the RAM and the
  20.   RGB output. I assumed these values (the same as Commando)
  21.  
  22.   bit 7 -- 220 ohm resistor  -- GREEN
  23.         -- 470 ohm resistor  -- GREEN
  24.         -- 1  kohm resistor  -- GREEN
  25.         -- 2.2kohm resistor  -- GREEN
  26.         -- 220 ohm resistor  -- RED
  27.         -- 470 ohm resistor  -- RED
  28.         -- 1  kohm resistor  -- RED
  29.   bit 0 -- 2.2kohm resistor  -- RED
  30.  
  31.   bit 7 -- unused
  32.         -- unused
  33.         -- unused
  34.         -- unused
  35.         -- 220 ohm resistor  -- BLUE
  36.         -- 470 ohm resistor  -- BLUE
  37.         -- 1  kohm resistor  -- BLUE
  38.   bit 0 -- 2.2kohm resistor  -- BLUE
  39.  
  40. ***************************************************************************/
  41. void karnov_vh_convert_color_prom(unsigned char *palette, unsigned short *colortable,const unsigned char *color_prom)
  42. {
  43.     int i;
  44.  
  45.     for (i = 0;i < Machine->drv->total_colors;i++)
  46.     {
  47.         int bit0,bit1,bit2,bit3;
  48.  
  49.         bit0 = (color_prom[0] >> 0) & 0x01;
  50.         bit1 = (color_prom[0] >> 1) & 0x01;
  51.         bit2 = (color_prom[0] >> 2) & 0x01;
  52.         bit3 = (color_prom[0] >> 3) & 0x01;
  53.         *(palette++) = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  54.         bit0 = (color_prom[0] >> 4) & 0x01;
  55.         bit1 = (color_prom[0] >> 5) & 0x01;
  56.         bit2 = (color_prom[0] >> 6) & 0x01;
  57.         bit3 = (color_prom[0] >> 7) & 0x01;
  58.         *(palette++) = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  59.         bit0 = (color_prom[Machine->drv->total_colors] >> 0) & 0x01;
  60.         bit1 = (color_prom[Machine->drv->total_colors] >> 1) & 0x01;
  61.         bit2 = (color_prom[Machine->drv->total_colors] >> 2) & 0x01;
  62.         bit3 = (color_prom[Machine->drv->total_colors] >> 3) & 0x01;
  63.         *(palette++) = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  64.  
  65.         color_prom++;
  66.     }
  67. }
  68.  
  69. /******************************************************************************/
  70.  
  71. void karnov_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  72. {
  73.     int my,mx,offs,color,tile;
  74.     int scrollx=READ_WORD (&karnov_scroll[0]);
  75.     int scrolly=READ_WORD (&karnov_scroll[2]);
  76.  
  77.     /* 1st area is stored along X-axis... */
  78.     mx=-1; my=0;
  79.     for (offs = 0;offs < 0x800; offs += 2) {
  80.         mx++;
  81.         if (mx==32) {mx=0; my++;}
  82.  
  83.         if (!dirty_f[offs]) continue; else dirty_f[offs]=0;
  84.  
  85.         tile=READ_WORD (&karnov_foreground[offs]);
  86.         color = tile >> 12;
  87.         tile = tile&0x7ff;
  88.  
  89.         drawgfx(bitmap_f,Machine->gfx[1],tile,
  90.             color, 0,0, 16*mx,16*my,
  91.              0,TRANSPARENCY_NONE,0);
  92.     }
  93.  
  94.     /* 2nd area is stored along Y-axis... */
  95.     mx=0; my=-1;
  96.     for (offs = 0x800 ;offs < 0x1000; offs += 2) {
  97.         my++;
  98.         if (my==32) {my=0; mx++;}
  99.  
  100.         if (!dirty_f[offs]) continue; else dirty_f[offs]=0;
  101.  
  102.         tile=READ_WORD (&karnov_foreground[offs]);
  103.         color = tile >> 12;
  104.         tile=tile&0x7ff;
  105.  
  106.         drawgfx(bitmap_f,Machine->gfx[1],tile,
  107.             color, 0,0, 16*mx,16*my,
  108.              0,TRANSPARENCY_NONE,0);
  109.     }
  110.  
  111.     scrolly=-scrolly;
  112.     scrollx=-scrollx;
  113.     copyscrollbitmap(bitmap,bitmap_f,1,&scrollx,1,&scrolly,0,TRANSPARENCY_NONE,0);
  114.  
  115.     /* Sprites */
  116.     for (offs = 0;offs <0x800;offs += 8) {
  117.         int x,y,sprite,sprite2,colour,fx,fy,extra;
  118.  
  119.         y=READ_WORD (&buffered_spriteram[offs]);
  120.         if (!(y&0x8000)) continue;
  121.  
  122.         y=y&0x1ff;
  123.         sprite=READ_WORD (&buffered_spriteram[offs+6]);
  124.         colour=sprite>>12;
  125.         sprite=sprite&0xfff;
  126.         x=READ_WORD (&buffered_spriteram[offs+4])&0x1ff;
  127.  
  128.         fx=READ_WORD (&buffered_spriteram[offs+2]);
  129.         if ((fx&0x10)) extra=1; else extra=0;
  130.         fy=fx&0x2;
  131.         fx=fx&0x4;
  132.  
  133.         if (extra) y=y+16;
  134.  
  135.         /* Convert the co-ords..*/
  136.         x=(x+16)%0x200;
  137.         y=(y+16)%0x200;
  138.         x=256 - x;
  139.         y=256 - y;
  140.  
  141.         /* Y Flip determines order of multi-sprite */
  142.         if (extra && fy) {
  143.             sprite2=sprite;
  144.             sprite++;
  145.         }
  146.         else sprite2=sprite+1;
  147.  
  148.         drawgfx(bitmap,Machine->gfx[2],
  149.                 sprite,
  150.                 colour,fx,fy,x,y,
  151.                 0,TRANSPARENCY_PEN,0);
  152.  
  153.         /* 1 more sprite drawn underneath */
  154.         if (extra)
  155.             drawgfx(bitmap,Machine->gfx[2],
  156.                 sprite2,
  157.                 colour,fx,fy,x,y+16,
  158.                 0,TRANSPARENCY_PEN,0);
  159.     }
  160.  
  161.     /* Draw character tiles */
  162.     for (offs = videoram_size - 2;offs >= 0;offs -= 2) {
  163.         tile=READ_WORD (&videoram[offs]);
  164.         if (!tile) continue;
  165.         color=tile>>14;
  166.         tile=tile&0xfff;
  167.         mx = (offs/2) % 32;
  168.         my = (offs/2) / 32;
  169.         drawgfx(bitmap,Machine->gfx[0],
  170.             tile,color,0,0,8*mx,8*my,
  171.             &Machine->drv->visible_area,TRANSPARENCY_PEN,0);
  172.     }
  173. }
  174.  
  175. void wndrplnt_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  176. {
  177.     int my,mx,offs,color,tile;
  178.     int scrollx=READ_WORD (&karnov_scroll[0]);
  179.     int scrolly=READ_WORD (&karnov_scroll[2]);
  180.  
  181.     /* 1st area is stored along X-axis... */
  182.     mx=-1; my=0;
  183.     for (offs = 0;offs < 0x800; offs += 2) {
  184.         mx++;
  185.         if (mx==32) {mx=0; my++;}
  186.  
  187.         if (!dirty_f[offs]) continue; else dirty_f[offs]=0;
  188.  
  189.         tile=READ_WORD (&karnov_foreground[offs]);
  190.         color = tile >> 12;
  191.         tile = tile&0x7ff;
  192.  
  193.         drawgfx(bitmap_f,Machine->gfx[1],tile,
  194.             color, 0,0, 16*mx,16*my,
  195.              0,TRANSPARENCY_NONE,0);
  196.     }
  197.  
  198.     /* 2nd area is stored along Y-axis... */
  199.     mx=0; my=-1;
  200.     for (offs = 0x800 ;offs < 0x1000; offs += 2) {
  201.         my++;
  202.         if (my==32) {my=0; mx++;}
  203.  
  204.         if (!dirty_f[offs]) continue; else dirty_f[offs]=0;
  205.  
  206.         tile=READ_WORD (&karnov_foreground[offs]);
  207.         color = tile >> 12;
  208.         tile=tile&0x7ff;
  209.  
  210.         drawgfx(bitmap_f,Machine->gfx[1],tile,
  211.             color, 0,0, 16*mx,16*my,
  212.              0,TRANSPARENCY_NONE,0);
  213.     }
  214.  
  215.     scrolly=-scrolly;
  216.     scrollx=-scrollx;
  217.     copyscrollbitmap(bitmap,bitmap_f,1,&scrollx,1,&scrolly,0,TRANSPARENCY_NONE,0);
  218.  
  219.     /* Sprites */
  220.     for (offs = 0;offs <0x800;offs += 8) {
  221.         int x,y,sprite,sprite2,colour,fx,fy,extra;
  222.  
  223.         y=READ_WORD (&buffered_spriteram[offs]);
  224.         if (!(y&0x8000)) continue;
  225.  
  226.         y=y&0x1ff;
  227.         sprite=READ_WORD (&buffered_spriteram[offs+6]);
  228.         colour=sprite>>12;
  229.         sprite=sprite&0xfff;
  230.         x=READ_WORD (&buffered_spriteram[offs+4])&0x1ff;
  231.  
  232.         fx=READ_WORD (&buffered_spriteram[offs+2]);
  233.         if ((fx&0x10)) extra=1; else extra=0;
  234.         fy=fx&0x2;
  235.         fx=fx&0x4;
  236.  
  237.         if (extra) y=y+16;
  238.  
  239.         /* Convert the co-ords..*/
  240.         x=(x+16)%0x200;
  241.         y=(y+16)%0x200;
  242.         x=256 - x;
  243.         y=256 - y;
  244.  
  245.         /* Y Flip determines order of multi-sprite */
  246.         if (extra && fy) {
  247.             sprite2=sprite;
  248.             sprite++;
  249.         }
  250.         else sprite2=sprite+1;
  251.  
  252.         drawgfx(bitmap,Machine->gfx[2],
  253.                 sprite,
  254.                 colour,fx,fy,x,y,
  255.                 0,TRANSPARENCY_PEN,0);
  256.  
  257.         /* 1 more sprite drawn underneath */
  258.         if (extra)
  259.             drawgfx(bitmap,Machine->gfx[2],
  260.                 sprite2,
  261.                 colour,fx,fy,x,y+16,
  262.                 0,TRANSPARENCY_PEN,0);
  263.     }
  264.  
  265.     /* Draw character tiles */
  266.     for (offs = videoram_size - 2;offs >= 0;offs -= 2) {
  267.         tile=READ_WORD (&videoram[offs]);
  268.         if (!tile) continue;
  269.         color=tile>>14;
  270.         tile=tile&0xfff;
  271.         my = (offs/2) % 32;
  272.         mx = (offs/2) / 32;
  273.         drawgfx(bitmap,Machine->gfx[0],
  274.             tile,color,0,0,8*mx,8*my,
  275.             &Machine->drv->visible_area,TRANSPARENCY_PEN,0);
  276.     }
  277. }
  278.  
  279. /******************************************************************************/
  280.  
  281. WRITE_HANDLER( karnov_foreground_w )
  282. {
  283.     COMBINE_WORD_MEM(&karnov_foreground[offset],data);
  284.     dirty_f[offset] = 1;
  285. }
  286.  
  287. /******************************************************************************/
  288.  
  289. void karnov_vh_stop (void)
  290. {
  291.     if (dirty_f) free(dirty_f);
  292.     if (karnov_foreground) free(karnov_foreground);
  293.     if (bitmap_f) osd_free_bitmap (bitmap_f);
  294. }
  295.  
  296. int karnov_vh_start (void)
  297. {
  298.     /* Allocate bitmaps */
  299.     if ((bitmap_f = osd_create_bitmap(512,512)) == 0) {
  300.         karnov_vh_stop ();
  301.         return 1;
  302.     }
  303.  
  304.     dirty_f=malloc(0x1000);
  305.     karnov_foreground=malloc(0x1000);
  306.     memset(karnov_foreground,0,0x1000);
  307.     memset(dirty_f,1,0x1000);
  308.  
  309.     return 0;
  310. }
  311.  
  312. /******************************************************************************/
  313.